package com.线程Thread;
@SuppressWarnings("all")
public class 静态代理 {
    /**  这是真正的Thread类启动线程的代理模式
 *         Monkey monkey = new Monkey();
 *         Thread thread = new Thread(monkey);  // 静态代理设计模式
 *         thread.start();  //创建线程，调用Monkey的run方法
 */
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        ThreadProxies thread = new ThreadProxies(tiger);
        thread.start();

        /**模拟静态代理 运行过程：
         * 1.先创建Tiger对象 tiger；因为已经继承了Animal所以不能继承Thread了，只能实现Runnable接口，并重写run方法；
         * Tiger tiger = new Tiger();
         *
         * 2.创建线程代理ThreadProxies，把tiger传进去，(因为tiger实现了Runnable)
         *  2.1 ThreadProxies thread = new ThreadProxies(tiger);
         *  2.2 public ThreadProxies(Runnable target) {
         *         this.target = target;
         *     }
         *
         * 3.调用thread.start();
         *   3.1 public void start() {
         *         start0();
         *        }
         *   3.2 public void start0() {
         *         run();
         *        }
         *    3.3 public void run() {
         *         if (target != null){
         *             target.run();  //因为动态绑定，tiger的引用传给了target，会调用tiger的run方法
         *         }
         *     }
         *
         */
    }
}

class Animal{
}
class Tiger extends Animal implements Runnable{
    //这里解释为什么要实现Runnable接口；
    //因为java是单继承的，继承了animal就不能继承Thread了，所以只能继承Runnable，重写方法
    @Override
    public void run() {
        System.out.println("Tiger嗷嗷叫");
    }
}

//ThreadProxies == 线程代理
class ThreadProxies {

    Runnable target;

    public ThreadProxies(Runnable target) {
        this.target = target;
    }

    public void run() {
        if (target != null){
            target.run();
        }
    }

    public void start() {
        start0();
    }

    public void start0() {
        run();
    }
}